module klang.klang.转换工厂.实例化代码.工具.工具_;
import 全局;
import std.conv: ·to = to;
import ··klang类型_ = klang.klang.类型.klang类型_;
import ··输出工具_ = klang.编译.输出工具.输出工具_;
import klang.编译.核心.核心_: 开始包含, 词典_, 整数_, 创建数组, 创建词典, 返回零值, 映射, 循环每个, 最小, 获取正规文件名函数_, 查找索引, 结尾包含, 文本包含, 按字符分割, 部分, 连接, 从后查找字符索引;
import klang.编译.类型.类型_: 基工厂_ = 节点工厂_, 基础符号_ = 符号_, 转换上下文_, 转换函数_, 输出解析器_, 转换支持_, 程序主机接口_, 打印助手_, EmitHint, IEmitTextWriter, 打印机_, 符号表_, 源映射范围_, 文本范围_, 三元结果_;
import klang.编译.类型.枚举值.枚举值_: SK;
import klang.编译.输出节点.输出节点_: EmitFlags, addEmitFlags, getOriginalNode_1, setSourceMapRange, 添加合成的前方注释, getSyntheticLeadingComments, setSyntheticLeadingComments, 合成注释_;
import klang.编译.语法节点.节点_: 基础节点_ = 节点_, 基础源文件_ = 源文件_, 基础令牌_ = 令牌_, 节点数组_;
import klang.klang.工具.klang工具_: 获取扩展符号标志, 获取节点的程序集;
import klang.klang.语法节点.Klang节点_: 节点_ = Klang节点_, 源文件_ = Klang源文件_, 标识符_ = Klang标识符_, Klang令牌_, 修饰符_, 语句_, 版本语句_, 表达式_, 块_, 测试单元语句_, 断言语句_, 变量语句_, 变量声明列表_, 变量声明_, 导入从版本成员_, 导入版本成员_, 导入成员块_, 导入从成员块_, 导入从成员_, 导入成员_, 程序声明_, 函数声明_, 形参声明_, 对象声明_, 方法声明_, 构建声明_, 如果语句_, 返回语句_, 抛出语句_, 属性声明_, 属性赋值_, 继承子句_, 结构声明节点_ = 结构声明_, 对象声明节点_ = 对象声明_, 外部修饰符声明_, 调用表达式_, 类型断言表达式_, 符号引用表达式_, 前缀一元表达式_, 二元表达式_, 类型引用_, 限定名_, 类型形参_, 获取源文件, 合成注释节点_ = 合成注释_;
import klang.klang.检查.klang检查_: Klang转换支持_, combineTypeMappers, createTypeMapper, instantiateType, instantiateTypes, 获取节点Id, 获取符号Id, 获取类型Id, 获取签名Id, 获取字面量类型的基约束类型, 获取父符号, 创建泛型引用, getTypeArguments, 获取签名从签名声明, getReturnTypeOfSignature, 获取类型节点的类型, 计算类型断言表达式, 获取源文件的程序声明, 获取符号的声明类型, 获取字面量标志;
import klang.klang.类型.klang类型_: 符号_ = Klang符号_, 类型_ = Klang类型_, 签名_ = Klang签名_, 字面量值_, KSK, 编译选项_, 节点标志_, 节点扩展_, 类型映射_, 类型标志_, Klang输出种类_, Klang打印选项_, 符号标志_, 复合标志_, klang解析的模块名称_, 内置类型_, 内部符号名_, 节点检查标志_, 签名标志_;
import klang.编译.节点访问.访问节点_: Visitor, visitNode, visitNodes;
import klang.编译.路径.路径_: 获取正规化路径组件组, 获取目录路径, 路径_;
import klang.klang.节点访问.Klang节点访问_: visitEachChild;
import klang.klang.节点工厂.Klang工厂_: 节点工厂标志_, 节点工厂_ = Klang节点工厂_;
import klang.klang.转换工厂.转换工具.Klang转换工具_: 获取输出文件名;
import klang.编译.输出工具.输出工具_: 创建文本写;
import klang.klang.打印输出.Klang打印输出_: 创建打印机 = klang创建打印机;
import klang.编译.工具.工具_: getParseTreeNode_1, 创建符号表;
import klang.klang.转换工厂.名称碎裂.Mangler_: Mangler, OutBuffer;
import klang.klang.转换工厂.实例化代码.类型.实例化使用类型_: 实例化引用标志_, 实例化引用_, 类型打印标志_, 类型打印环境_;
import klang.klang.转换工厂.实例化代码.实例化访问.实例化访问_: 实例化类型访问;
import klang.klang.转换工厂.实例化代码.中间码_: 项目声明的符号集合, fc, K;
import klang.klang.转换工厂.实例化代码.内置函数.内置函数_: 创建内置函数声明;
打印机_ 打印机;
打印机_ 创建类型打印机() {
    if (.打印机 is ··null!(打印机_)) {
        Klang打印选项_ 打印选项 = new Klang打印选项_(Klang输出种类_.无_);
        打印助手_ 打印助手 = 打印助手_();
        打印选项.removeComments = true;
        打印选项.输出英文关键字 = true;
        .打印机 = 创建打印机(打印选项, 打印助手);
    }
    return .打印机;
}
dstring 打印类型(节点_ tn) {
    ··输出工具_.EmitTextWriter 文本写 = 创建文本写(""d);
    打印机_ 类型打印机 = .创建类型打印机();
    类型打印机.writeNode(EmitHint.Unspecified, tn, 返回零值!(基础源文件_)(), 文本写);
    dstring result = 文本写.getText();
    文本写.clear();
    return result;
}
节点_ 实例化类型(类型_ type, 类型打印环境_ 环境) {
    if (type is ··null!(类型_)) {
        return 返回零值!(节点_)();
    }
    if ((type.标志 & 类型标志_.排除集类型_) != 0) {
        type = type.类型;
    }
    if ((type.标志 & 类型标志_.限定类型_) != 0) {
        if ((环境.标志 & 类型打印标志_.跳过限定符_) != 0) {
            return .实例化类型(type.类型, 环境);
        }
        else {
            节点_ 新节点;
            if ((type.复合标志 & 复合标志_.只读_) != 0) {
                新节点 = fc.创建类型限定类型(KSK.只读_, fc.创建括号类型(.实例化类型(type.类型, 环境)));
            }
            else if ((type.复合标志 & 复合标志_.恒定_) != 0) {
                新节点 = fc.创建类型限定类型(KSK.恒定_, fc.创建括号类型(.实例化类型(type.类型, 环境)));
            }
            else if ((type.复合标志 & 复合标志_.共享_) != 0) {
                新节点 = fc.创建类型限定类型(KSK.共享_, fc.创建括号类型(.实例化类型(type.类型, 环境)));
            }
            else {
                新节点 = .实例化类型(type.类型, 环境);
            }
            return 新节点;
        }
    }
    if ((type.复合标志 & 复合标志_.内置类型字面量_) != 0) {
        if ((环境.标志 & 类型打印标志_.字面量提升_) != 0) {
            类型_ 基类型 = 获取字面量类型的基约束类型(type);
            if (基类型 != type) {
                return .实例化类型(基类型, 环境);
            }
        }
        else {
            字面量值_ 值 = type.值;
            if ((type.标志 & 类型标志_.文本字面量8_) != 0) {
                dstring 值内容 = 值.获取文本(获取字面量标志(类型标志_.文本字面量8_));
                return fc.创建字面量类型(fc.创建文本字面量(值内容, 节点标志_.C));
            }
            else if ((type.标志 & 类型标志_.文本字面量16_) != 0) {
                dstring 值内容 = 值.获取文本(获取字面量标志(类型标志_.文本字面量16_));
                return fc.创建字面量类型(fc.创建文本字面量(值内容, 节点标志_.W));
            }
            else if ((type.标志 & 类型标志_.文本字面量32_) != 0) {
                dstring 值内容 = 值.获取文本(获取字面量标志(类型标志_.文本字面量32_));
                return fc.创建字面量类型(fc.创建文本字面量(值内容, 节点标志_.D));
            }
            else if ((type.标志 & 类型标志_.字符字面量8_) != 0) {
                int 内容 = 值.获取整数(获取字面量标志(类型标志_.字符字面量8_));
                return fc.创建字面量类型(fc.创建字符字面量(内容, 节点标志_.C));
            }
            else if ((type.标志 & 类型标志_.字符字面量16_) != 0) {
                int 内容 = 值.获取整数(获取字面量标志(类型标志_.字符字面量16_));
                return fc.创建字面量类型(fc.创建字符字面量(内容, 节点标志_.W));
            }
            else if ((type.标志 & 类型标志_.字符字面量32_) != 0) {
                int 内容 = 值.获取整数(获取字面量标志(类型标志_.字符字面量32_));
                return fc.创建字面量类型(fc.创建字符字面量(内容, 节点标志_.D));
            }
            else if ((type.标志 & 类型标志_.整数字面量8_) != 0) {
                int 内容 = 值.获取整数(获取字面量标志(类型标志_.整数字面量8_));
                return fc.创建字面量类型(fc.创建数字字面量(内容, 节点标志_.无));
            }
            else if ((type.标志 & 类型标志_.整数字面量16_) != 0) {
                int 内容 = 值.获取整数(获取字面量标志(类型标志_.整数字面量16_));
                return fc.创建字面量类型(fc.创建数字字面量(内容, 节点标志_.无));
            }
            else if ((type.标志 & 类型标志_.整数字面量32_) != 0) {
                int 内容 = 值.获取整数(获取字面量标志(类型标志_.整数字面量32_));
                return fc.创建字面量类型(fc.创建数字字面量(内容, 节点标志_.无));
            }
            else if ((type.标志 & 类型标志_.整数字面量64_) != 0) {
                int 内容 = 值.获取整数(获取字面量标志(类型标志_.整数字面量64_));
                return fc.创建字面量类型(fc.创建数字字面量(内容, 节点标志_.L));
            }
            else if ((type.标志 & 类型标志_.正整数字面量8_) != 0) {
                int 内容 = 值.获取整数(获取字面量标志(类型标志_.正整数字面量8_));
                return fc.创建字面量类型(fc.创建数字字面量(内容, 节点标志_.U));
            }
            else if ((type.标志 & 类型标志_.正整数字面量16_) != 0) {
                int 内容 = 值.获取整数(获取字面量标志(类型标志_.正整数字面量16_));
                return fc.创建字面量类型(fc.创建数字字面量(内容, 节点标志_.U));
            }
            else if ((type.标志 & 类型标志_.正整数字面量32_) != 0) {
                int 内容 = 值.获取整数(获取字面量标志(类型标志_.正整数字面量32_));
                return fc.创建字面量类型(fc.创建数字字面量(内容, 节点标志_.U));
            }
            else if ((type.标志 & 类型标志_.正整数字面量64_) != 0) {
                ulong 内容 = 值.获取正整数64(获取字面量标志(类型标志_.正整数字面量64_));
                return fc.创建字面量类型(fc.创建数字字面量(内容, 节点标志_.UL));
            }
            else if ((type.标志 & 类型标志_.小数字面量32_) != 0) {
                double 内容 = 值.获取小数(获取字面量标志(类型标志_.小数字面量32_));
                return fc.创建字面量类型(fc.创建小数字面量(内容, 节点标志_.F));
            }
            else if ((type.标志 & 类型标志_.小数字面量64_) != 0) {
                double 内容 = 值.获取小数(获取字面量标志(类型标志_.小数字面量64_));
                return fc.创建字面量类型(fc.创建小数字面量(内容, 节点标志_.D));
            }
            else if ((type.标志 & 类型标志_.虚数字面量32_) != 0) {
                double 内容 = 值.获取小数(获取字面量标志(类型标志_.虚数字面量32_));
                return fc.创建字面量类型(fc.创建小数字面量(内容, 节点标志_.FI));
            }
            else if ((type.标志 & 类型标志_.虚数字面量64_) != 0) {
                double 内容 = 值.获取小数(获取字面量标志(类型标志_.虚数字面量64_));
                return fc.创建字面量类型(fc.创建小数字面量(内容, 节点标志_.I));
            }
            else if ((type.标志 & 类型标志_.真字面量_) != 0) {
                return fc.创建字面量类型(fc.创建关键字类型节点(KSK.真_));
            }
            else if ((type.标志 & 类型标志_.假字面量_) != 0) {
                return fc.创建字面量类型(fc.创建关键字类型节点(KSK.假_));
            }
        }
    }
    if ((type.标志 & 类型标志_.联合_) != 0 && (type.标志 & 类型标志_.枚举字面量_) != 0 || (type.标志 & 类型标志_.枚举_) != 0) {
        符号_ 符号 = (cast(符号_)(type.符号));
        if (符号 !is ··null!(符号_)) {
            return .实例化类型(符号.枚举基类型, 环境);
        }
    }
    if ((type.标志 & 类型标志_.枚举字面量_) != 0 && (type.标志 & 类型标志_.联合_) == 0) {
        符号_ parentSymbol = 获取父符号((cast(符号_)(type.符号)));
        return .实例化类型(parentSymbol.枚举基类型, 环境);
    }
    if ((type.标志 & 类型标志_.未知_) != 0) {
        return fc.创建关键字类型节点(KSK.未知_);
    }
    if ((type.标志 & 类型标志_.任意_) != 0) {
        return fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_));
    }
    if ((type.标志 & 类型标志_.不及_) != 0) {
        return fc.创建关键字类型节点(KSK.无值_);
    }
    if ((type.标志 & 类型标志_.无值_) != 0) {
        return fc.创建关键字类型节点(KSK.无值_);
    }
    if ((type.标志 & 类型标志_.空值_) != 0) {
        if ((type.复合标志 & 复合标志_.空址_) != 0) {
            return fc.创建关键字类型节点(KSK.空址_);
        }
        if ((type.复合标志 & 复合标志_.零值_) != 0) {
            return fc.创建关键字类型节点(KSK.零值_);
        }
        return fc.创建关键字类型节点(KSK.空值_);
    }
    if ((type.标志 & 类型标志_.字节_) != 0) {
        return fc.创建关键字类型节点(KSK.字节_);
    }
    if ((type.标志 & 类型标志_.真字面量_) != 0) {
        return fc.创建关键字类型节点(KSK.真_);
    }
    if ((type.标志 & 类型标志_.假字面量_) != 0) {
        return fc.创建关键字类型节点(KSK.假_);
    }
    if ((type.标志 & 类型标志_.真假_) != 0) {
        return fc.创建关键字类型节点(KSK.真假_);
    }
    if ((type.标志 & 类型标志_.文本8_) != 0) {
        return fc.创建关键字类型节点(KSK.文本8_);
    }
    if ((type.标志 & 类型标志_.文本16_) != 0) {
        return fc.创建关键字类型节点(KSK.文本16_);
    }
    if ((type.标志 & 类型标志_.文本32_) != 0) {
        return fc.创建关键字类型节点(KSK.文本_);
    }
    if ((type.标志 & 类型标志_.字符8_) != 0) {
        return fc.创建关键字类型节点(KSK.字符8_);
    }
    if ((type.标志 & 类型标志_.字符16_) != 0) {
        return fc.创建关键字类型节点(KSK.字符16_);
    }
    if ((type.标志 & 类型标志_.字符32_) != 0) {
        return fc.创建关键字类型节点(KSK.字符_);
    }
    if ((type.标志 & 类型标志_.整数8_) != 0) {
        return fc.创建关键字类型节点(KSK.整数8_);
    }
    if ((type.标志 & 类型标志_.整数16_) != 0) {
        return fc.创建关键字类型节点(KSK.整数16_);
    }
    if ((type.标志 & 类型标志_.整数32_) != 0) {
        return fc.创建关键字类型节点(KSK.整数32_);
    }
    if ((type.标志 & 类型标志_.整数64_) != 0) {
        return fc.创建关键字类型节点(KSK.整数_);
    }
    if ((type.标志 & 类型标志_.正整数8_) != 0) {
        return fc.创建关键字类型节点(KSK.正整数8_);
    }
    if ((type.标志 & 类型标志_.正整数16_) != 0) {
        return fc.创建关键字类型节点(KSK.正整数16_);
    }
    if ((type.标志 & 类型标志_.正整数32_) != 0) {
        return fc.创建关键字类型节点(KSK.正整数32_);
    }
    if ((type.标志 & 类型标志_.正整数64_) != 0) {
        return fc.创建关键字类型节点(KSK.正整数_);
    }
    if ((type.标志 & 类型标志_.小数32_) != 0) {
        return fc.创建关键字类型节点(KSK.小数32_);
    }
    if ((type.标志 & 类型标志_.小数64_) != 0) {
        return fc.创建关键字类型节点(KSK.小数_);
    }
    if ((type.标志 & 类型标志_.虚数32_) != 0) {
        return fc.创建关键字类型节点(KSK.虚数32_);
    }
    if ((type.标志 & 类型标志_.虚数64_) != 0) {
        return fc.创建关键字类型节点(KSK.虚数_);
    }
    if ((type.标志 & 类型标志_.复数64_) != 0) {
        return fc.创建关键字类型节点(KSK.复数64_);
    }
    if ((type.标志 & 类型标志_.复数128_) != 0) {
        return fc.创建关键字类型节点(KSK.复数_);
    }
    if ((type.标志 & 类型标志_.复合_) != 0) {
        if ((type.复合标志 & 复合标志_.数组_) != 0) {
            节点_ 类型_ = .实例化类型(type.类型, 环境);
            类型打印环境_ 保存 = 环境;
            环境.标志 &= ~类型打印标志_.字面量提升_;
            节点_ 长度_ = .实例化类型(type.长度, 环境);
            环境 = 保存;
            return fc.创建数组类型(类型_, 长度_);
        }
        if ((type.复合标志 & 复合标志_.动态_) != 0) {
            节点_ 类型_ = .实例化类型(type.类型, 环境);
            return fc.创建动态数组类型(类型_);
        }
        if ((type.复合标志 & 复合标志_.变长_) != 0) {
            节点_ 类型_ = .实例化类型(type.类型, 环境);
            return fc.创建变长参数(类型_);
        }
        if ((type.复合标志 & 复合标志_.列表_) != 0) {
            节点_[] 类型组 = 创建数组!(节点_)();
            foreach (类型_ t; type.类型.类型组) {
                节点_ 类型_ = .实例化类型(t, 环境);
                .追加!(节点_)(类型组, 类型_);
            }
            return fc.创建元组类型节点(fc.f·创建节点数组!(节点_)(new 节点数组_!(节点_)(类型组)));
        }
        if ((type.复合标志 & 复合标志_.词典_) != 0) {
            节点_[] 类型组 = 创建数组!(节点_)();
            foreach (类型_ t; type.类型组) {
                节点_ 类型_ = .实例化类型(t, 环境);
                .追加!(节点_)(类型组, 类型_);
            }
            assert(类型组.length == 2, "词典键值类型错误"c);
            return fc.创建词典类型(类型组[0], 类型组[1]);
        }
        if ((type.复合标志 & 复合标志_.元组_) != 0) {
            节点_[] 类型组 = 创建数组!(节点_)();
            foreach (类型_ t; type.类型组) {
                节点_ 类型_ = .实例化类型(t, 环境);
                .追加!(节点_)(类型组, 类型_);
            }
            return fc.创建元组类型节点(fc.f·创建节点数组!(节点_)(new 节点数组_!(节点_)(类型组)));
        }
        if ((type.复合标志 & 复合标志_.指针_) != 0) {
            基础符号_ 符号 = type.符号;
            if ((type.复合标志 & 复合标志_.委托_) != 0) {
                return fc.创建括号类型(fc.创建指针类型(.实例化类型(type.类型, 环境)));
            }
            return fc.创建指针类型(.实例化类型(type.类型, 环境));
        }
    }
    if ((type.标志 & 类型标志_.可选类型_) != 0) {
        return .实例化类型(type.类型, 环境);
    }
    if ((type.复合标志 & 复合标志_.虚拟外部类型_) != 0) {
        dstring 名称;
        if (type.实例化名称 != ""d) {
            名称 = type.实例化名称;
        }
        else {
            名称 = type.名称;
        }
        if (项目声明的符号集合.具有(名称)) {
            return 项目声明的符号集合.获取(名称).类型引用;
        }
        实例化引用_ TZ = new 实例化引用_();
        TZ.引用标志 |= 实例化引用标志_.外部虚拟_ | 实例化引用标志_.类型声明_;
        TZ.类型引用 = fc.创建类型引用(fc.创建起始限定名(fc.创建标识符(名称)));
        TZ.类型声明 = fc.创建别名声明(fc.创建文本标识符(名称), fc.转为令牌(KSK.未知_), ··null!(节点数组_!(类型形参_)), fc.f·创建节点数组!(修饰符_)([(cast(修饰符_)(fc.转为令牌(KSK.声明_)))], false));
        .获取合成节点扩展(TZ.类型引用).解析类型 = type;
        项目声明的符号集合.p·设置(名称, TZ);
        return TZ.类型引用;
    }
    if ((type.复合标志 & 复合标志_.虚拟外部函数_) != 0) {
        dstring 名称;
        if (type.实例化名称 != ""d) {
            名称 = type.实例化名称;
        }
        else {
            名称 = type.名称;
        }
        if (项目声明的符号集合.具有(名称)) {
            return 项目声明的符号集合.获取(名称).类型引用;
        }
        实例化引用_ TZ = new 实例化引用_();
        TZ.引用标志 |= 实例化引用标志_.外部虚拟函数_ | 实例化引用标志_.函数声明_;
        TZ.类型引用 = fc.创建类型引用(fc.创建起始限定名(fc.创建标识符(名称)));
        TZ.函数声明 = 创建内置函数声明(名称, 环境);
        .获取合成节点扩展(TZ.类型引用).解析类型 = type;
        项目声明的符号集合.p·设置(名称, TZ);
        return TZ.类型引用;
    }
    if ((type.复合标志 & 复合标志_.匿名_) != 0) {
        签名_ sig = type.当前需要实例化的签名;
        dstring 名称;
        if (type.实例化名称 != ""d) {
            名称 = type.实例化名称;
        }
        else {
            // 函数  方法;
            Mangler m = new Mangler();
            m.碎裂实例化类型(type);
            dstring chs = m.outString();
            // 没实现 如果需要 this 加 'M',
            名称 = "\\01_D"d ~ chs;
            type.实例化名称 = 名称;
        }
        if ((type.复合标志 & 复合标志_.泛型引用_) != 0) {
            if (项目声明的符号集合.具有(名称)) {
                实例化引用_ TZ = 项目声明的符号集合.获取(名称);
                if ((环境.标志 & 类型打印标志_.生成全局站位符_) != 0) {
                    return 项目声明的符号集合.获取(名称).类型引用;
                }
                if ((TZ.引用标志 & 实例化引用标志_.站位符_) == 0) {
                    return 项目声明的符号集合.获取(名称).类型引用;
                }
            }
            if (项目声明的符号集合.具有(名称)) {
                实例化引用_ TZ = 项目声明的符号集合.获取(名称);
                TZ.引用标志 &= ~实例化引用标志_.站位符_;
            }
            //
            环境.标志 |= 类型打印标志_.泛型实例化_;
            bool 恢复站位符 = false;
            if ((环境.标志 & 类型打印标志_.生成全局站位符_) != 0) {
                恢复站位符 = true;
                环境.标志 &= ~类型打印标志_.生成全局站位符_;
            }
            类型映射_ 储存类型映射 = type.映射;
            类型映射_ 当前映射 = type.映射;
            if (sig.类型映射 !is ··null!(类型映射_)) {
                当前映射 = combineTypeMappers(cast(类型映射_)(当前映射), sig.类型映射);
            }
            type.映射 = cast(类型映射_)(当前映射);
            实例化类型访问(type, 环境);
            if (恢复站位符) {
                环境.标志 |= 类型打印标志_.生成全局站位符_;
            }
            环境.标志 &= ~类型打印标志_.泛型实例化_;
            type.映射 = cast(类型映射_)(储存类型映射);
            return 项目声明的符号集合.获取(名称).类型引用;
        }
        else if ((sig.标志 & 签名标志_.是泛型签名_) != 0) {
            环境.标志 |= 类型打印标志_.泛型实例化_;
            if (项目声明的符号集合.具有(名称)) {
                实例化引用_ TZ = 项目声明的符号集合.获取(名称);
                if ((环境.标志 & 类型打印标志_.生成全局站位符_) != 0) {
                    return 项目声明的符号集合.获取(名称).类型引用;
                }
                if ((TZ.引用标志 & 实例化引用标志_.站位符_) == 0) {
                    return 项目声明的符号集合.获取(名称).类型引用;
                }
            }
            if (项目声明的符号集合.具有(名称)) {
                实例化引用_ TZ = 项目声明的符号集合.获取(名称);
                TZ.引用标志 &= ~实例化引用标志_.站位符_;
            }
            bool 恢复站位符 = false;
            if ((环境.标志 & 类型打印标志_.生成全局站位符_) != 0) {
                恢复站位符 = true;
                环境.标志 &= ~类型打印标志_.生成全局站位符_;
            }
            类型映射_ 储存类型映射 = type.映射;
            if ((type.映射 !is ··null!(类型映射_)) && (sig.类型映射 !is ··null!(类型映射_))) {
                type.映射 = combineTypeMappers(type.映射, sig.类型映射);
            }
            else if (sig.类型映射 !is ··null!(类型映射_)) {
                type.映射 = sig.类型映射;
            }
            实例化类型访问(type, 环境);
            if (恢复站位符) {
                环境.标志 |= 类型打印标志_.生成全局站位符_;
            }
            环境.标志 &= ~类型打印标志_.泛型实例化_;
            type.映射 = cast(类型映射_)(储存类型映射);
            return 项目声明的符号集合.获取(名称).类型引用;
        }
        else {
            if (项目声明的符号集合.具有(名称)) {
                实例化引用_ TZ = 项目声明的符号集合.获取(名称);
                if ((环境.标志 & 类型打印标志_.生成全局站位符_) != 0) {
                    return 项目声明的符号集合.获取(名称).类型引用;
                }
                if ((TZ.引用标志 & 实例化引用标志_.站位符_) == 0) {
                    return 项目声明的符号集合.获取(名称).类型引用;
                }
            }
            else if ((环境.标志 & 类型打印标志_.生成全局站位符_) != 0) {
                实例化引用_ TZ = new 实例化引用_();
                TZ.引用标志 |= 实例化引用标志_.站位符_;
                TZ.类型引用 = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符(名称)));
                项目声明的符号集合.p·设置(名称, TZ);
                return 项目声明的符号集合.获取(名称).类型引用;
            }
            if (项目声明的符号集合.具有(名称)) {
                实例化引用_ TZ = 项目声明的符号集合.获取(名称);
                TZ.引用标志 &= ~实例化引用标志_.站位符_;
            }
            实例化类型访问(type, 环境);
            return 项目声明的符号集合.获取(名称).类型引用;
        }
    }
    else if ((type.复合标志 & 复合标志_.泛型引用_) != 0) {
        dstring 名称;
        if (type.实例化名称 != ""d) {
            名称 = type.实例化名称;
        }
        else {
            名称 = .获取符号名(type.泛型目标.符号);
            类型_[] 类型实参组 = getTypeArguments(type);
            dstring[] 类型实参文本组 = 创建数组!(dstring)();
            foreach (类型_ t; 类型实参组) {
                节点_ tn = .实例化类型(t, 环境);
                .追加!(dstring)(类型实参文本组, .打印类型(tn));
            }
            dstring 中间 = ""d;
            if (类型实参文本组.length > 1) {
                dstring 实参文本 = 连接(类型实参文本组, ", "d);
                中间 = "!("d ~ 实参文本 ~ ")"d;
            }
            else if (类型实参文本组.length == 1) {
                中间 = "!"d ~ 类型实参文本组[0];
            }
            dstring 前面 = .生成类型声明符号名((cast(符号_)(type.泛型目标.符号)));
            if (中间 != ""d) {
                名称 = 前面 ~ 中间 ~ "."d ~ 名称;
            }
            else {
                名称 = 前面;
            }
            type.实例化名称 = 名称;
        }
        if (项目声明的符号集合.具有(名称)) {
            实例化引用_ TZ = 项目声明的符号集合.获取(名称);
            if ((环境.标志 & 类型打印标志_.生成全局站位符_) != 0) {
                return 项目声明的符号集合.获取(名称).类型引用;
            }
            if ((TZ.引用标志 & 实例化引用标志_.站位符_) == 0) {
                return 项目声明的符号集合.获取(名称).类型引用;
            }
        }
        if (项目声明的符号集合.具有(名称)) {
            实例化引用_ TZ = 项目声明的符号集合.获取(名称);
            TZ.引用标志 &= ~实例化引用标志_.站位符_;
        }
        环境.标志 |= 类型打印标志_.泛型实例化_;
        bool 恢复站位符 = false;
        if ((环境.标志 & 类型打印标志_.生成全局站位符_) != 0) {
            恢复站位符 = true;
            环境.标志 &= ~类型打印标志_.生成全局站位符_;
        }
        实例化类型访问(type, 环境);
        if (恢复站位符) {
            环境.标志 |= 类型打印标志_.生成全局站位符_;
        }
        环境.标志 &= ~类型打印标志_.泛型实例化_;
        return 项目声明的符号集合.获取(名称).类型引用;
    }
    else if ((type.复合标志 & (复合标志_.类_ | 复合标志_.结构_ | 复合标志_.接口_ | 复合标志_.类型_ | 复合标志_.事件_)) != 0) {
        dstring 名称;
        if (type.实例化名称 != ""d) {
            名称 = type.实例化名称;
        }
        else {
            名称 = .生成类型声明符号名((cast(符号_)(type.符号)));
            type.实例化名称 = 名称;
        }
        if (项目声明的符号集合.具有(名称)) {
            实例化引用_ TZ = 项目声明的符号集合.获取(名称);
            if ((环境.标志 & 类型打印标志_.生成全局站位符_) != 0) {
                return 项目声明的符号集合.获取(名称).类型引用;
            }
            if ((TZ.引用标志 & 实例化引用标志_.站位符_) == 0) {
                return 项目声明的符号集合.获取(名称).类型引用;
            }
        }
        else if ((环境.标志 & 类型打印标志_.生成全局站位符_) != 0) {
            实例化引用_ TZ = new 实例化引用_();
            TZ.引用标志 |= 实例化引用标志_.站位符_;
            TZ.类型引用 = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符(名称)));
            项目声明的符号集合.p·设置(名称, TZ);
            return 项目声明的符号集合.获取(名称).类型引用;
        }
        if (项目声明的符号集合.具有(名称)) {
            实例化引用_ TZ = 项目声明的符号集合.获取(名称);
            TZ.引用标志 &= ~实例化引用标志_.站位符_;
        }
        实例化类型访问(type, 环境);
        return 项目声明的符号集合.获取(名称).类型引用;
    }
    return 返回零值!(节点_)();
}
dstring 生成类型声明符号名(符号_ 符号) {
    dstring[] names = .计算名称碎裂部件(符号);
    return 连接(names, "."d);
}
dstring[] 计算名称碎裂部件(符号_ s) {
    void delegate(符号_) 内部计算;
    dstring[] name;
    void 内部计算·func(符号_ s) {
        符号_ p;
        p = (cast(符号_)(s.父符号));
        if (p !is ··null!(符号_)) {
            if ((p.标志 & 符号标志_.程序集_) != 0) {
                name = .追加!(dstring)(p.碎裂名称[0 .. $], name);
            }
            else {
                name = .追加!(dstring)([.获取符号名(p)], name);
                内部计算(p);
            }
        }
        else if ((s.声明组 !is ··null!(基础节点_[])) && s.声明组.length > 0) {
            基础节点_ 节点 = s.声明组[0].父节点;
            if (节点 !is ··null!(基础节点_)) {
                if (节点.目标种类 == KSK.测试单元语句) {
                    程序声明_ 程序集 = 获取节点的程序集(节点);
                    p = (cast(符号_)(程序集.符号));
                    dstring[] xs = .追加!(dstring)(["unittest_N"d ~ .获取节点文本Id(节点)], name);
                    name = .追加!(dstring)(p.碎裂名称[0 .. $], xs);
                    return;
                }
            }
        }
        return;
    }
    内部计算 = &内部计算·func;
    if (s.碎裂名称 !is ··null!(dstring[])) {
        return s.碎裂名称;
    }
    name = 创建数组!(dstring)();
    内部计算(s);
    s.碎裂名称 = .追加!(dstring)(name, .获取符号名(s));
    return s.碎裂名称;
}
基础节点_ 返回空() {
    return 返回零值!(基础节点_)();
}
基础节点_ 设置输出标志(基础节点_ n) {
    if (n is ··null!(基础节点_)) {
        return n;
    }
    return addEmitFlags(n, EmitFlags.不缩进合成块_);
}
节点扩展_ 获取节点扩展(基础节点_ 节点) {
    if (节点 is ··null!(基础节点_)) {
        return ··null!(节点扩展_);
    }
    节点 = getOriginalNode_1(节点);
    if (节点.扩展 !is ··null!(void*)) {
        return (cast(节点扩展_)(节点.扩展));
    }
    return ··null!(节点扩展_);
}
符号_ 获取解析符号(基础节点_ 节点) {
    if (节点 is ··null!(基础节点_)) {
        return ··null!(符号_);
    }
    节点扩展_ 扩展 = .获取节点扩展(节点);
    if (扩展 !is ··null!(节点扩展_)) {
        return 扩展.解析符号;
    }
    return ··null!(符号_);
}
符号_ 获取节点符号(基础节点_ 节点) {
    节点 = getOriginalNode_1(节点);
    return (cast(符号_)(节点.符号));
}
dstring 获取符号文本Id(基础符号_ s) {
    return ·to!(dstring)(获取符号Id((cast(符号_)(s))));
}
dstring 获取类型文本Id(类型_ t) {
    return ·to!(dstring)(获取类型Id(t));
}
dstring 获取节点文本Id(基础节点_ n) {
    return ·to!(dstring)(获取节点Id(n));
}
dstring 获取签名文本Id(签名_ n) {
    return ·to!(dstring)(获取签名Id(n));
}
dstring 获取符号名(基础符号_ s) {
    if (s.名称 == 内部符号名_.新建_) {
        return "__ctor"d;
    }
    else if (s.名称 == 内部符号名_.释放_) {
        return "__dtor"d;
    }
    else if (s.名称 == 内部符号名_.索引_) {
        // 不支持
        return "__opI"d;
    }
    else if (s.名称 == 内部符号名_.运算符_) {
        // 不支持
        return "__op"d;
    }
    long i = 从后查找字符索引(s.名称, cast(dchar)'|');
    if (i != -1) {
        return s.名称[i .. $];
    }
    return s.名称;
}
节点扩展_ 获取合成节点扩展(基础节点_ 节点) {
    if (节点.扩展 is ··null!(void*)) {
        节点.扩展 = (cast(void*)(new 节点扩展_(节点, 节点检查标志_.无_)));
    }
    return (cast(节点扩展_)(节点.扩展));
}
void 访问节点数组(T)(T[] ns, void delegate(T) cb) {
    {
        for (int i = 0; i < ns.length; ++i) {
            cb(ns[i]);
        }
    }
}
T 设置源映射(T)(基础节点_ sou, T node, 源映射范围_ re = ··null!(源映射范围_)) {
    if (re !is ··null!(源映射范围_)) {
        re.source = sou;
    }
    else {
        node.source = sou;
    }
    基础节点_ n = setSourceMapRange(node, re);
    return (cast(T)(n));
}
节点_ 清除分隔距离(基础节点_ n) {
    合成注释_[] cs = getSyntheticLeadingComments(n);
    if ((cs !is ··null!(合成注释_[])) && cs.length > 0) {
        foreach (合成注释_ c; cs) {
            c.前方新行数量 = 0;
        }
    }
    return (cast(节点_)(setSyntheticLeadingComments(n, cs)));
}
节点_ 生成分隔注释(dstring 注释, int 分隔距离 = 2) {
    if (!开始包含(注释, " "d)) {
        注释 = " "d ~ 注释;
    }
    合成注释_ 合成注释 = new 合成注释_(SK.单行注释, 注释, -1, -1, false, true);
    合成注释.前方新行数量 = 分隔距离;
    合成注释节点_ n = fc.创建合成注释();
    节点_ xn = (cast(节点_)(添加合成的前方注释(n, 合成注释)));
    return xn;
}
节点数组_!(修饰符_) 根据符号更新修饰符(基础符号_ s) {
    节点数组_!(修饰符_) 修饰符 = .符号标志转为修饰符数组(s.标志);
    if ((cast(符号_)(s)).外部修饰符 !is ··null!(外部修饰符声明_)) {
        if ((修饰符 !is null) && (修饰符.原型 !is ··null!(修饰符_[]))) {
            .追加!(修饰符_)(cast(修饰符_[])(修饰符.原型), (cast(符号_)(s)).外部修饰符);
        }
        else {
            修饰符 = fc.f·创建节点数组!(修饰符_)([(cast(修饰符_)((cast(符号_)(s)).外部修饰符))], false);
        }
    }
    return 修饰符;
}
节点数组_!(修饰符_) 符号标志转为修饰符数组(ulong 符号标志) {
    修饰符_[] 节点数组 = 创建数组!(修饰符_)();
    if ((符号标志 & 符号标志_.私有_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.私有_))));
    }
    if ((符号标志 & 符号标志_.保护_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.保护_))));
    }
    if ((符号标志 & 符号标志_.只读_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.只读_))));
    }
    if ((符号标志 & 符号标志_.恒定_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.恒定_))));
    }
    if ((符号标志 & 符号标志_.共享_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.共享_))));
    }
    if ((符号标志 & 符号标志_.静态_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.静态_))));
    }
    if ((符号标志 & 符号标志_.引用_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.引用_))));
    }
    if ((符号标志 & 符号标志_.局部_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.局部_))));
    }
    if ((符号标志 & 符号标志_.固定_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.固定_))));
    }
    if ((符号标志 & 符号标志_.声明_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.声明_))));
    }
    if ((符号标志 & 符号标志_.返回_) != 0) {
        .追加!(修饰符_)(节点数组, (cast(修饰符_)(fc.转为令牌(KSK.返回_))));
    }
    if (节点数组.length > 0) {
        return fc.f·创建节点数组!(修饰符_)(new 节点数组_!(修饰符_)(节点数组));
    }
    return ··null!(节点数组_!(修饰符_));
}
